/*#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <limits.h>  
#include "generation.h"
#include "matching.h"
#include "preprocess.h" 

// 动态缓冲区实现
typedef struct {
    char* data;
    size_t length;
    size_t capacity;
} DynamicBuffer;

void dynamic_buffer_init(DynamicBuffer* buffer, size_t initial_capacity) {
    buffer->data = malloc(initial_capacity);
    buffer->length = 0;
    buffer->capacity = initial_capacity;
    if (buffer->data) buffer->data[0] = '\0';
}

void dynamic_buffer_append(DynamicBuffer* buffer, const char* data, size_t len) {
    if (buffer->length + len + 1 >= buffer->capacity) {
        size_t new_capacity = buffer->capacity * 2;
        char* new_data = realloc(buffer->data, new_capacity);
        if (!new_data) return;
        buffer->data = new_data;
        buffer->capacity = new_capacity;
    }
    
    memcpy(buffer->data + buffer->length, data, len);
    buffer->length += len;
    buffer->data[buffer->length] = '\0';
}

void dynamic_buffer_free(DynamicBuffer* buffer) {
    free(buffer->data);
    buffer->data = NULL;
    buffer->length = 0;
    buffer->capacity = 0;
}

// 初始化模板生成选项
GenerationOptions generation_options_default() {
    GenerationOptions options = {
        .merge_variables = true,
        .update_existing = true
    };
    return options;
}

// 根据LCS结果生成新模板
char* generate_template_from_lcs(const char** tokens, uint32_t token_count, 
                                const char** template_tokens, uint32_t template_token_count) {
    if (token_count == 0 || template_token_count == 0) return NULL;
    
    // 计算LCS矩阵
    LCSMatrix* matrix = lcs_matrix_init(token_count + 1, template_token_count + 1);
    if (!matrix) return NULL;
    
    for (uint32_t i = 0; i <= token_count; i++) {
        for (uint32_t j = 0; j <= template_token_count; j++) {
            if (i == 0 || j == 0) {
                matrix->matrix[i][j] = 0;
            } else if (strcmp(tokens[i-1], template_tokens[j-1]) == 0) {
                matrix->matrix[i][j] = matrix->matrix[i-1][j-1] + 1;
            } else {
                matrix->matrix[i][j] = (matrix->matrix[i-1][j] > matrix->matrix[i][j-1]) ? 
                                      matrix->matrix[i-1][j] : matrix->matrix[i][j-1];
            }
        }
    }
    
    // 构建新模板 - 使用动态缓冲区
    DynamicBuffer buffer;
    dynamic_buffer_init(&buffer, 1024);
    
    uint32_t i = token_count, j = template_token_count;
    bool in_variable = false;
    
    while (i > 0 && j > 0) {
        if (strcmp(tokens[i-1], template_tokens[j-1]) == 0) {
            // 公共部分
            if (in_variable) {
                // 结束变量部分
                // 创建一个新缓冲区，在前面添加<*>
                DynamicBuffer new_buffer;
                dynamic_buffer_init(&new_buffer, buffer.capacity + 10);
                
                dynamic_buffer_append(&new_buffer, "<*> ", 4);
                
                // 添加原有内容
                if (buffer.length > 0) {
                    dynamic_buffer_append(&new_buffer, buffer.data, buffer.length);
                }
                
                // 替换原缓冲区
                dynamic_buffer_free(&buffer);
                buffer = new_buffer;
                in_variable = false;
            }
            
            // 添加公共token（注意顺序，从后向前）
            char* temp = buffer.data;
            size_t temp_len = buffer.length;
            
            // 创建新缓冲区，先放当前token，再放原有内容
            DynamicBuffer new_buffer;
            dynamic_buffer_init(&new_buffer, buffer.capacity);
            
            // 添加当前token
            dynamic_buffer_append(&new_buffer, tokens[i-1], strlen(tokens[i-1]));
            dynamic_buffer_append(&new_buffer, " ", 1);
            
            // 添加原有内容
            if (temp_len > 0) {
                dynamic_buffer_append(&new_buffer, temp, temp_len);
            }
            
            // 替换原缓冲区
            dynamic_buffer_free(&buffer);
            buffer = new_buffer;
            
            i--;
            j--;
        } else if (matrix->matrix[i-1][j] > matrix->matrix[i][j-1]) {
            // 当前token在日志中但不在模板中（变量）
            if (!in_variable) {
                in_variable = true;
            }
            i--;
        } else {
            // 当前token在模板中但不在日志中
            j--;
        }
    }
    
    // 处理剩余的变量部分 - 只有在还有未处理的日志token时才需要追加
    if (i > 0) {
        // 创建一个新的缓冲区，在前面添加<*>
        DynamicBuffer new_buffer;
        dynamic_buffer_init(&new_buffer, buffer.capacity + 10);
        
        // 添加<*>到新缓冲区
        dynamic_buffer_append(&new_buffer, "<*> ", 4);
        
        // 添加原有内容
        if (buffer.length > 0) {
            dynamic_buffer_append(&new_buffer, buffer.data, buffer.length);
        }
        
        // 替换原缓冲区
        dynamic_buffer_free(&buffer);
        buffer = new_buffer;
    }
    
    lcs_matrix_free(matrix);
    
    // 确保缓冲区以空字符结尾
    if (buffer.length > 0) {
        // 移除可能存在的末尾空格
        if (buffer.data[buffer.length-1] == ' ') {
            buffer.data[buffer.length-1] = '\0';
            buffer.length--;
        } else {
            dynamic_buffer_append(&buffer, "", 1); // 确保以空字符结尾
        }
    } else {
        dynamic_buffer_append(&buffer, "", 1); // 确保以空字符结尾
    }
    
    return buffer.data;
}

// 更新现有模板
bool update_existing_template(LogTemplate* template, const char** tokens, uint32_t token_count) {
    if (!template || !template->template_str) return false;
    
    // 将模板字符串分词
    uint32_t template_token_count = 0;
    char** template_tokens = tokenize_template(template->template_str, &template_token_count);
    
    if (!template_tokens) return false;
    
    // 生成新模板
    char* new_template_str = generate_template_from_lcs(tokens, token_count, 
                                                       (const char**)template_tokens, template_token_count);
    
    // 释放模板分词结果
    for (uint32_t i = 0; i < template_token_count; i++) {
        free(template_tokens[i]);
    }
    free(template_tokens);
    
    if (!new_template_str) return false;
    
    // 更新模板
    free(template->template_str);
    template->template_str = new_template_str;
    template->ref_count++;
    
    return true;
}

// 添加新模板到分组
bool add_new_template_to_group(TemplateGroup* group, const char* template_str) {
    if (!group || !template_str) return false;
    
    // 检查是否需要扩展
    if (group->template_count >= group->template_capacity) {
        uint32_t new_capacity = group->template_capacity * 2;
        LogTemplate** new_templates = realloc(group->templates, new_capacity * sizeof(LogTemplate*));
        if (!new_templates) return false;
        
        group->templates = new_templates;
        group->template_capacity = new_capacity;
    }
    
    // 创建新模板
    LogTemplate* new_template = malloc(sizeof(LogTemplate));
    if (!new_template) return false;
    
    new_template->template_str = strdup(template_str);
    if (!new_template->template_str) {
        free(new_template);
        return false;
    }
    
    new_template->ref_count = 1;
    
    // 添加到分组
    group->templates[group->template_count++] = new_template;
    return true;
}

// 处理模板匹配和生成
int process_template_generation(GroupManager* gm, int group_id, 
                                const char** tokens, uint32_t token_count,
                                GenerationOptions options) {
    if (!gm || group_id < 0) return -1;
    
    TemplateGroup* group = group_manager_get_group(gm, group_id);
    if (!group) return -1;
    
    // 如果没有模板，直接添加新模板
    if (group->template_count == 0) {
        // 构建初始模板（将所有token连接起来）
        char* initial_template = malloc(1024 * sizeof(char));
        if (!initial_template) return -1;
        
        initial_template[0] = '\0';
        uint32_t pos = 0;
        
        for (uint32_t i = 0; i < token_count; i++) {
            size_t token_len = strlen(tokens[i]);
            if (pos + token_len + 1 < 1024) {
                strcpy(initial_template + pos, tokens[i]);
                strcpy(initial_template + pos + token_len, " ");
                pos += token_len + 1;
            }
        }
        
        // 移除末尾空格
        if (pos > 0) {
            initial_template[pos - 1] = '\0';
        }
        
        bool success = add_new_template_to_group(group, initial_template);
        free(initial_template);
        return success ? 0 : -1; // 返回新模板的索引
    }
    
    // 查找匹配的模板
    MatchResult match = find_matching_template(tokens, token_count, group->group_key, group);
    
    if (match.matched && options.update_existing) {
        // 更新现有模板
        LogTemplate* template_to_update = group->templates[match.template_index];
        bool update_success = update_existing_template(template_to_update, tokens, token_count);
        return update_success ? match.template_index : -1;
    } else if (match.matched) {
        // 匹配但不更新，返回匹配的模板索引
        return match.template_index;
    } else {
        // 添加新模板
        // 构建新模板字符串
        char* new_template = malloc(1024 * sizeof(char));
        if (!new_template) return -1;
        
        new_template[0] = '\0';
        uint32_t pos = 0;
        
        for (uint32_t i = 0; i < token_count; i++) {
            size_t token_len = strlen(tokens[i]);
            if (pos + token_len + 1 < 1024) {
                strcpy(new_template + pos, tokens[i]);
                strcpy(new_template + pos + token_len, " ");
                pos += token_len + 1;
            }
        }
        
        // 移除末尾空格
        if (pos > 0) {
            new_template[pos - 1] = '\0';
        }
        
        bool success = add_new_template_to_group(group, new_template);
        free(new_template);
        // 返回新模板的索引，注意：group->template_count 是 uint32_t，但函数返回 int，所以需要检查是否溢出
        if (success) {
            // 由于 group->template_count 是 uint32_t，而返回值是 int，所以确保不会超过 INT_MAX
            if (group->template_count > INT_MAX) {
                return -1; // 理论上不应该有这么多模板，但安全起见
            }
            return (int)(group->template_count - 1);
        } else {
            return -1;
        }
    }
}
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <limits.h>
#include <math.h>
#include "generation.h"
#include "matching.h"
#include "preprocess.h"
#include "grouping.h"

// 添加 MIN 和 MAX 宏定义
#ifndef MIN
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#endif

#ifndef MAX
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#endif

// 动态缓冲区实现
typedef struct {
    char* data;
    size_t length;
    size_t capacity;
} DynamicBuffer;

void dynamic_buffer_init(DynamicBuffer* buffer, size_t initial_capacity) {
    buffer->data = malloc(initial_capacity);
    buffer->length = 0;
    buffer->capacity = initial_capacity;
    if (buffer->data) buffer->data[0] = '\0';
}

void dynamic_buffer_append(DynamicBuffer* buffer, const char* data, size_t len) {
    if (buffer->length + len + 1 >= buffer->capacity) {
        size_t new_capacity = buffer->capacity * 2;
        char* new_data = realloc(buffer->data, new_capacity);
        if (!new_data) return;
        buffer->data = new_data;
        buffer->capacity = new_capacity;
    }
    
    memcpy(buffer->data + buffer->length, data, len);
    buffer->length += len;
    buffer->data[buffer->length] = '\0';
}

void dynamic_buffer_free(DynamicBuffer* buffer) {
    free(buffer->data);
    buffer->data = NULL;
    buffer->length = 0;
    buffer->capacity = 0;
}

// 初始化模板生成选项
GenerationOptions generation_options_default() {
    GenerationOptions options = {
        .merge_variables = true,
        .update_existing = true
    };
    return options;
}

// 检查模板质量
bool is_template_quality_acceptable(const char* template_str) {
    if (!template_str) return false;
    
    // 分词
    uint32_t token_count = 0;
    char** tokens = tokenize_template(template_str, &token_count);
    if (!tokens) return false;
    
    // 计算固定部分比例
    uint32_t fixed_count = 0;
    for (uint32_t i = 0; i < token_count; i++) {
        if (strcmp(tokens[i], "<*>") != 0) {
            fixed_count++;
        }
    }
    
    // 释放内存
    for (uint32_t i = 0; i < token_count; i++) {
        free(tokens[i]);
    }
    free(tokens);
    
    // 要求至少有2个固定部分，且固定部分比例不低于30%
    return fixed_count >= 2 && (double)fixed_count / token_count >= 0.3;
}

// 改进的相似度计算
double calculate_similarity_improved(const char** tokens1, uint32_t len1, const char** tokens2, uint32_t len2) {
    // 计算模板中固定部分的数量和位置
    uint32_t fixed_count = 0;
    bool* is_fixed = malloc(len2 * sizeof(bool));
    for (uint32_t i = 0; i < len2; i++) {
        is_fixed[i] = (strcmp(tokens2[i], "<*>") != 0);
        if (is_fixed[i]) fixed_count++;
    }
    
    if (fixed_count == 0) {
        free(is_fixed);
        return 0.0;
    }
    
    // 计算LCS长度，但只考虑固定部分
    uint32_t lcs_len = 0;
    for (uint32_t i = 0, j = 0; i < len1 && j < len2; ) {
        if (strcmp(tokens1[i], tokens2[j]) == 0) {
            lcs_len++;
            i++;
            j++;
        } else if (!is_fixed[j]) {
            // 跳过模板中的变量部分
            j++;
        } else {
            // 跳过日志中的不匹配部分
            i++;
        }
    }
    
    double base_similarity = (double)lcs_len / fixed_count;
    
    // 添加位置权重：前面的固定部分更重要
    double position_weight = 1.0;
    for (uint32_t i = 0; i < MIN(len1, len2); i++) {
        if (i < len2 && is_fixed[i] && 
            (i >= len1 || strcmp(tokens1[i], tokens2[i]) != 0)) {
            // 前面的固定部分不匹配，降低权重
            position_weight -= 0.2 * (1.0 - (double)i / MIN(len1, len2));
        }
    }
    position_weight = MAX(0.3, position_weight);
    
    // 添加长度惩罚
    double length_penalty = 1.0 - (fabs((double)len1 - (double)len2) / (len1 + len2 + 1));
    
    free(is_fixed);
    
    // 综合相似度
    return base_similarity * position_weight * length_penalty;
}

// 根据LCS结果生成新模板（改进版）
char* generate_template_from_lcs_improved(const char** tokens, uint32_t token_count, 
                                         const char** template_tokens, uint32_t template_token_count) {
    if (token_count == 0 || template_token_count == 0) return NULL;
    
    // 计算LCS矩阵
    LCSMatrix* matrix = lcs_matrix_init(token_count + 1, template_token_count + 1);
    if (!matrix) return NULL;
    
    for (uint32_t i = 0; i <= token_count; i++) {
        for (uint32_t j = 0; j <= template_token_count; j++) {
            if (i == 0 || j == 0) {
                matrix->matrix[i][j] = 0;
            } else if (strcmp(tokens[i-1], template_tokens[j-1]) == 0) {
                matrix->matrix[i][j] = matrix->matrix[i-1][j-1] + 1;
            } else {
                matrix->matrix[i][j] = (matrix->matrix[i-1][j] > matrix->matrix[i][j-1]) ? 
                                      matrix->matrix[i-1][j] : matrix->matrix[i][j-1];
            }
        }
    }
    
    // 构建新模板 - 使用动态缓冲区
    DynamicBuffer buffer;
    dynamic_buffer_init(&buffer, 1024);
    
    uint32_t i = token_count, j = template_token_count;
    bool in_variable = false;
    uint32_t consecutive_mismatch = 0; // 跟踪连续不匹配的数量
    
    while (i > 0 && j > 0) {
        if (strcmp(tokens[i-1], template_tokens[j-1]) == 0) {
            // 重置连续不匹配计数
            consecutive_mismatch = 0;
            
            // 公共部分处理
            if (in_variable) {
                // 只有在连续多个不匹配后才结束变量部分
                if (consecutive_mismatch >= 2) { // 至少2个连续不匹配才标记为变量
                    // 结束变量部分
                    DynamicBuffer new_buffer;
                    dynamic_buffer_init(&new_buffer, buffer.capacity + 10);
                    
                    dynamic_buffer_append(&new_buffer, "<*> ", 4);
                    
                    if (buffer.length > 0) {
                        dynamic_buffer_append(&new_buffer, buffer.data, buffer.length);
                    }
                    
                    dynamic_buffer_free(&buffer);
                    buffer = new_buffer;
                    in_variable = false;
                } else {
                    // 将之前的"不匹配"视为固定部分
                    for (uint32_t k = 0; k < consecutive_mismatch; k++) {
                        // 将这些token添加为固定部分
                        DynamicBuffer new_buffer;
                        dynamic_buffer_init(&new_buffer, buffer.capacity);
                        
                        dynamic_buffer_append(&new_buffer, tokens[i+k], strlen(tokens[i+k]));
                        dynamic_buffer_append(&new_buffer, " ", 1);
                        
                        if (buffer.length > 0) {
                            dynamic_buffer_append(&new_buffer, buffer.data, buffer.length);
                        }
                        
                        dynamic_buffer_free(&buffer);
                        buffer = new_buffer;
                    }
                    in_variable = false;
                }
            }
            
            // 添加公共token
            DynamicBuffer new_buffer;
            dynamic_buffer_init(&new_buffer, buffer.capacity);
            
            dynamic_buffer_append(&new_buffer, tokens[i-1], strlen(tokens[i-1]));
            dynamic_buffer_append(&new_buffer, " ", 1);
            
            if (buffer.length > 0) {
                dynamic_buffer_append(&new_buffer, buffer.data, buffer.length);
            }
            
            dynamic_buffer_free(&buffer);
            buffer = new_buffer;
            
            i--;
            j--;
        } else if (matrix->matrix[i-1][j] > matrix->matrix[i][j-1]) {
            // 当前token在日志中但不在模板中
            consecutive_mismatch++;
            if (!in_variable && consecutive_mismatch >= 2) { // 至少2个连续不匹配才开始变量部分
                in_variable = true;
            }
            i--;
        } else {
            // 当前token在模板中但不在日志中
            j--;
        }
    }
    
    // 处理剩余部分 - 更加保守
    if (i > 0 && consecutive_mismatch >= 2) {
        // 只有在有足够多的连续不匹配时才添加变量标记
        DynamicBuffer new_buffer;
        dynamic_buffer_init(&new_buffer, buffer.capacity + 10);
        
        dynamic_buffer_append(&new_buffer, "<*> ", 4);
        
        if (buffer.length > 0) {
            dynamic_buffer_append(&new_buffer, buffer.data, buffer.length);
        }
        
        dynamic_buffer_free(&buffer);
        buffer = new_buffer;
    } else if (i > 0) {
        // 将剩余部分添加为固定部分
        for (uint32_t k = 0; k < i; k++) {
            DynamicBuffer new_buffer;
            dynamic_buffer_init(&new_buffer, buffer.capacity);
            
            dynamic_buffer_append(&new_buffer, tokens[k], strlen(tokens[k]));
            dynamic_buffer_append(&new_buffer, " ", 1);
            
            if (buffer.length > 0) {
                dynamic_buffer_append(&new_buffer, buffer.data, buffer.length);
            }
            
            dynamic_buffer_free(&buffer);
            buffer = new_buffer;
        }
    }
    
    lcs_matrix_free(matrix);
    
    // 确保缓冲区以空字符结尾
    if (buffer.length > 0) {
        // 移除可能存在的末尾空格
        if (buffer.data[buffer.length-1] == ' ') {
            buffer.data[buffer.length-1] = '\0';
            buffer.length--;
        } else {
            dynamic_buffer_append(&buffer, "", 1); // 确保以空字符结尾
        }
    } else {
        dynamic_buffer_append(&buffer, "", 1); // 确保以空字符结尾
    }
    
    return buffer.data;
}

// 更新现有模板
bool update_existing_template(LogTemplate* template, const char** tokens, uint32_t token_count) {
    if (!template || !template->template_str) return false;
    
    // 将模板字符串分词
    uint32_t template_token_count = 0;
    char** template_tokens = tokenize_template(template->template_str, &template_token_count);
    
    if (!template_tokens) return false;
    
    // 生成新模板
    char* new_template_str = generate_template_from_lcs_improved(tokens, token_count, 
                                                               (const char**)template_tokens, template_token_count);
    
    // 检查模板质量
    if (!is_template_quality_acceptable(new_template_str)) {
        free(new_template_str);
        // 释放模板分词结果
        for (uint32_t i = 0; i < template_token_count; i++) {
            free(template_tokens[i]);
        }
        free(template_tokens);
        return false;
    }
    
    // 释放模板分词结果
    for (uint32_t i = 0; i < template_token_count; i++) {
        free(template_tokens[i]);
    }
    free(template_tokens);
    
    if (!new_template_str) return false;
    
    // 更新模板
    free(template->template_str);
    template->template_str = new_template_str;
    template->ref_count++;
    
    return true;
}

// 添加新模板到分组
bool add_new_template_to_group(TemplateGroup* group, const char* template_str) {
    if (!group || !template_str) return false;
    
    // 检查是否需要扩展
    if (group->template_count >= group->template_capacity) {
        uint32_t new_capacity = group->template_capacity * 2;
        LogTemplate** new_templates = realloc(group->templates, new_capacity * sizeof(LogTemplate*));
        if (!new_templates) return false;
        
        group->templates = new_templates;
        group->template_capacity = new_capacity;
    }
    
    // 创建新模板
    LogTemplate* new_template = malloc(sizeof(LogTemplate));
    if (!new_template) return false;
    
    new_template->template_str = strdup(template_str);
    if (!new_template->template_str) {
        free(new_template);
        return false;
    }
    
    new_template->ref_count = 1;
    
    // 添加到分组
    group->templates[group->template_count++] = new_template;
    return true;
}

// 处理模板匹配和生成
int process_template_generation(GroupManager* gm, int group_id, 
                                const char** tokens, uint32_t token_count,
                                GenerationOptions options) {
    if (!gm || group_id < 0) return -1;
    
    TemplateGroup* group = group_manager_get_group(gm, group_id);
    if (!group) return -1;
    
    // 如果没有模板，直接添加新模板
    if (group->template_count == 0) {
        // 构建初始模板（将所有token连接起来）
        char* initial_template = malloc(1024 * sizeof(char));
        if (!initial_template) return -1;
        
        initial_template[0] = '\0';
        uint32_t pos = 0;
        
        for (uint32_t i = 0; i < token_count; i++) {
            size_t token_len = strlen(tokens[i]);
            if (pos + token_len + 1 < 1024) {
                strcpy(initial_template + pos, tokens[i]);
                strcpy(initial_template + pos + token_len, " ");
                pos += token_len + 1;
            }
        }
        
        // 移除末尾空格
        if (pos > 0) {
            initial_template[pos - 1] = '\0';
        }
        
        bool success = add_new_template_to_group(group, initial_template);
        free(initial_template);
        return success ? 0 : -1; // 返回新模板的索引
    }
    
    // 查找匹配的模板（使用改进的相似度计算）
    MatchResult match = {false, -1, 0.0, NULL};
    
    // 遍历所有模板，寻找匹配的模板
    for (uint32_t i = 0; i < group->template_count; i++) {
        if (!group->templates[i] || !group->templates[i]->template_str) {
            continue;
        }
        
        // 将模板字符串分词
        uint32_t template_token_count = 0;
        char** template_tokens = tokenize_template(group->templates[i]->template_str, &template_token_count);
        
        if (!template_tokens) {
            continue;
        }
        
        // 计算相似度（使用改进的相似度计算）
        double similarity = calculate_similarity_improved(tokens, token_count, 
                                                       (const char**)template_tokens, template_token_count);
        
        // 检查模板质量
        bool is_quality_acceptable = is_template_quality_acceptable(group->templates[i]->template_str);
        
        // 释放模板分词结果
        free_tokens(template_tokens, template_token_count);
        
        // 检查是否超过阈值且模板质量可接受
        if (similarity > SIMILARITY_THRESHOLD && similarity > match.similarity && is_quality_acceptable) {
            match.matched = true;
            match.template_index = i;
            match.similarity = similarity;
            match.matched_template = group->templates[i]->template_str;
        }
    }
    
    if (match.matched && options.update_existing) {
        // 更新现有模板
        LogTemplate* template_to_update = group->templates[match.template_index];
        bool update_success = update_existing_template(template_to_update, tokens, token_count);
        return update_success ? match.template_index : -1;
    } else if (match.matched) {
        // 匹配但不更新，返回匹配的模板索引
        return match.template_index;
    } else {
        // 添加新模板
        // 构建新模板字符串
        char* new_template = malloc(1024 * sizeof(char));
        if (!new_template) return -1;
        
        new_template[0] = '\0';
        uint32_t pos = 0;
        
        for (uint32_t i = 0; i < token_count; i++) {
            size_t token_len = strlen(tokens[i]);
            if (pos + token_len + 1 < 1024) {
                strcpy(new_template + pos, tokens[i]);
                strcpy(new_template + pos + token_len, " ");
                pos += token_len + 1;
            }
        }
        
        // 移除末尾空格
        if (pos > 0) {
            new_template[pos - 1] = '\0';
        }
        
        // 检查模板质量
        if (!is_template_quality_acceptable(new_template)) {
            free(new_template);
            return -1;
        }
        
        bool success = add_new_template_to_group(group, new_template);
        free(new_template);
        // 返回新模板的索引，注意：group->template_count 是 uint32_t，但函数返回 int，所以需要检查是否溢出
        if (success) {
            // 由于 group->template_count 是 uint32_t，而返回值是 int，所以确保不会超过 INT_MAX
            if (group->template_count > INT_MAX) {
                return -1; // 理论上不应该有这么多模板，但安全起见
            }
            return (int)(group->template_count - 1);
        } else {
            return -1;
        }
    }
}